package com.longlonggo.service;

import com.longlonggo.dao.base.IBaseDao;
import com.longlonggo.entity.BaseEntity;
import com.longlonggo.util.PageUtil;
import lombok.Data;

import java.util.List;
import java.util.Map;

/**
 * 基础业务层，需要被其他业务层继承
 *
 * @author 石马人山 me@longlonggo.com
 * @version 100-000-000<br/>
 * @Created 2017年8月9日 上午11:15:55
 * </p>
 * @description <br/>
 */
@Data
public abstract class BaseService {


    /**
     * 注入base的持久化层
     *
     * @return 注入成功的持久化层
     */
    protected abstract IBaseDao getDao();

    /**
     * 保存实体(可以保存非空对象，不做非空判断)
     *
     * @param entity 实体
     * @return 返回保存后的id
     */
    public int insert(BaseEntity entity) {
        return this.getDao().insert(entity);
    }

    /**
     * 保存实体(保存时做非空判断，为空值不保存)
     *
     * @param entity 实体
     * @return 返回保存后的id
     */
    public int insertSelective(BaseEntity entity) {
        return this.getDao().insertSelective(entity);
    }

    /**
     * 根据ID查询实体信息
     *
     * @param id 实体ID
     * @return 返回base实体
     */
    public BaseEntity selectByPrimaryKey(int id) {
        return this.getDao().selectByPrimaryKey(id);
    }

    /**
     * 根据id删除实体
     *
     * @param id 要删除的主键id
     */
    public void deleteByPrimaryKey(int id) {
        this.getDao().deleteByPrimaryKey(id);
    }

    /**
     * 更新实体(做非空判断，为空值不做更新)
     *
     * @param entity 实体
     */
    public void updateByPrimaryKeySelective(BaseEntity entity) {
        this.getDao().updateByPrimaryKeySelective(entity);
    }

    /**
     * 更新实体(不做非空判断，空值也会执行更新)
     *
     * @param entity 实体
     */
    public void updateByPrimaryKey(BaseEntity entity) {
        this.getDao().updateByPrimaryKey(entity);
    }

    /**
     * 更新实体(更新包含更新大字段)
     *
     * @param entity 实体
     */
    public void updateByPrimaryKeyWithBLOBs(BaseEntity entity) {
        this.getDao().updateByPrimaryKeyWithBLOBs(entity);
    }

    /**
     * 查询所有
     *
     * @return 返回list数组
     */
    public List<?> queryAll() {
        return this.getDao().queryAll();
    }

    /**
     * 分页查询
     *
     * @param page  分页实体
     * @param order 排序字段
     * @param order order 排序方式,true:asc{}fales:desc
     * @return 返回list数组
     */
    public List<?> queryAllByPage(PageUtil page, String orderBy, boolean order) {
        return this.getDao().queryAllByPage(page, orderBy, order);
    }

    /**
     * 查询数据表中记录集合总数
     *
     * @return 返回查询总条数
     */
    public int count() {
        return this.getDao().count();
    }

    /**
     * 批量新增
     *
     * @param list 新增数据
     */
    public void saveBatch(List<?> list) {
        this.getDao().saveBatch(list);
    }

    /**
     * 根据id集合实现批量的删除
     *
     * @param ids id集合
     */
    public void deleteBatch(String[] ids) {
        this.getDao().deleteBatch(ids);
    }

    /**
     * 根据map条件条件查询列表
     *
     * @param map 查询条件集合 key:条件名 value:值
     * @return 列表
     */
    public List<?> queryListByMap(Map<String, Object> map) {
        return this.getDao().queryListByMap(map);
    }

    /**
     * 分页查询<br/>
     * 根据map条件查询列表
     *
     * @param map     查询条件集合 key:条件名 value：值
     * @param page    分页条件
     * @param orderBy 排序字段
     * @param order   排序方式{}true:asc[降序]{}false:desc[升序]
     * @return 列表集合
     */
    public List<?> queryListByMapPage(Map<String, Object> map, PageUtil page, String orderBy, Boolean order) {
        return this.getDao().queryListByMapPage(map, page, orderBy, order);
    }

    /**
     * 根据map条件查询记录总数
     *
     * @param map 查询条件集合 key:条件名 value:值
     * @return
     */
    public int countByMap(Map<String, Object> map) {
        return this.getDao().countByMap(map);
    }

    /**
     * 根据map条件以及组织好的where条件语句查询列表
     *
     * @param map     查询条件集合 key:条件名 value:值
     * @param where   条件语句
     * @param page    分页对象
     * @param orderBy 依据排序字段
     * @param order   排序方式
     * @return 列表数据
     */
    public List<?> queryBySearch(Map<String, Object> map, String where, PageUtil page, String orderBy, Boolean order) {
        return this.getDao().queryBySearch(map, where, page, orderBy, order);
    }

    /**
     * 根据map条件以及组织好的where条件语句查询总数
     *
     * @param map   查询条件集合 key:条件名 value:值
     * @param where 条件语句
     * @return 总数
     */
    public int countBySearch(Map<String, Object> map, String where) {
        return this.getDao().countBySearch(map, where);
    }

    /**
     * 批量更新
     *
     * @param list 需要更新的对象集合
     */
    public void updateBatchById(int id, List<?> list) {
        this.getDao().updateBatchById(id, list);
    }

    /**
     * 批量更新
     *
     * @param list 需要更新的对象集合
     */
    public void saveBatchById(int id, List<?> list) {
        this.getDao().saveBatchById(id, list);
    }

    /**
     * 批量更新实体
     *
     * @param list 实体集合
     */
    public void updatesBatch(List<?> list) {
        this.getDao().updatesBatch(list);
    }

    /**
     * 通过订单编号获取订单实体<br/>
     * 使用本函数必须保证订单编号在查询的表中是唯一的
     *
     * @param no 订单编号
     * @return 订单实体
     */
    public BaseEntity getEntityByNo(String no) {
        return this.getDao().getEntityByNo(no);
    }

    /**
     * 根据编号获取数据集合
     *
     * @param code 组编号
     * @return 组数据集
     */
    public List<?> queryListByCode(String code) {
        return this.getDao().queryListByCode(code);
    }
}
